home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / cl181.zip / CL.HPT < prev    next >
Text File  |  1993-04-26  |  11KB  |  447 lines
  1. /*
  2.     cl.hpt -- Container Lite v 1.81 template
  3.     (C) Copyright 1993  John Webster Small
  4.     All rights reserved
  5. */
  6.  
  7.  
  8. #ifndef cl_hpt
  9. #define cl_hpt
  10.  
  11. #ifndef cl_hpp
  12. #include "cl.hpp"
  13. #endif
  14.  
  15.  
  16. /*  ITEM descriptors  */
  17.  
  18. template <class ITEM>
  19. int CL_D_cmp(const ITEM * D1, const ITEM * D2)
  20. { return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
  21.  
  22. template <class ITEM>
  23. inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void)
  24. { CLcmP(defaultCmP,ITEM) = CL_D_cmp;
  25.  return CLcmPcast((cmP? cmP : defaultCmP),void); }
  26.  
  27. #define ITEM_NO_REL_OPS(ITEM)  \
  28. inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void)  \
  29. { return CLcmPcast((cmP? cmP : CLcmP0(ITEM)),void); }
  30.  
  31.  
  32. template <class ITEM>
  33.     inline void * CL_D_ASSIGN(ITEM * D,
  34.         ITEM * S)
  35.     { *D = *S; return (void *) D; }
  36. #define ITEM_TEST_ASSIGN(ITEM)  \
  37.     inline void * CL_D_ASSIGN(ITEM * D,  \
  38.         ITEM * S)  \
  39.     { return (void *) ((*D = *S)? D : 0); }
  40. #define ITEM_NO_ASSIGN(ITEM)  \
  41.     inline void * CL_D_ASSIGN(ITEM * D,  \
  42.         ITEM *)  \
  43.     { return (void *) 0; }
  44.  
  45.  
  46. template <class ITEM>
  47.     inline void * CL_D_NEW(ITEM * thiS)
  48.     { return (void *) new ITEM(*thiS); }
  49. #define ITEM_CLONE(ITEM)  \
  50.     inline void * CL_D_NEW(ITEM * thiS)  \
  51.     { return (void *) thiS->clone(); }
  52. #define ITEM_NO_COPYINIT(ITEM)  \
  53.     inline void * CL_D_NEW(ITEM *)  \
  54.     { return (void *) 0; }
  55.  
  56. template <class ITEM>
  57.     inline void CL_D_DELETE(ITEM * D)
  58.     { delete D; }
  59. #define ITEM_STRM_MUT_DELETE(ITEM)  \
  60.     inline void CL_D_DELETE(ITEM * D)  \
  61.     { if (!D->RefCount()) delete D; }
  62.  
  63. template <class ITEM>
  64.     inline int CL_D_LINK(ITEM *, void *)
  65.     { return 1; }
  66. #define ITEM_LINK(ITEM) inline int CL_D_LINK  \
  67.     (ITEM * D, void * B)           \
  68.     { return D->link(B); }
  69.  
  70. template <class ITEM>
  71.     inline void CL_D_UNLINK(ITEM *, void *)
  72.     {}
  73. #define ITEM_UNLINK(ITEM) inline void CL_D_UNLINK \
  74.     (ITEM * D, void * B)                      \
  75.     { D->unlink(B); }
  76.  
  77. template <class ITEM>
  78.     inline ostream& operator<<(ostream& os,
  79.         ITEM ** D)
  80.     { return os << **D << endm; }
  81. #define ITEM_STRM_INSERT(ITEM,ITEM_STRM_BASE)    \
  82.     inline ostream& operator<<(ostream& os,  \
  83.         ITEM ** D)                        \
  84.     { return os << *(ITEM_STRM_BASE *)*D; }
  85. #define ITEM_NO_STRM_INSERT(ITEM)                \
  86.     inline ostream& operator<<(ostream& os,  \
  87.         ITEM **) { return os; }
  88.  
  89. template <class ITEM>
  90.     inline istream& operator>>(istream& is,
  91.         ITEM ** D)
  92.     {
  93.         if ((*D = new ITEM()) != (ITEM *)0)
  94.             is >> **D >> nextm;
  95.         return is;
  96.     }
  97. #define ITEM_STRM_EXTRACT(ITEM,ITEM_STRM_BASE)   \
  98.     inline istream& operator>>(istream& is,  \
  99.         ITEM ** D)                       \
  100.     {                                        \
  101.         ITEM_STRM_BASE * S;              \
  102.         is >> S;                         \
  103.         *D = (ITEM *) S;         \
  104.         return is;                       \
  105.     }
  106. #define ITEM_NO_STRM_EXTRACT(ITEM)               \
  107.     inline istream& operator>>(istream& is,  \
  108.         ITEM **) { return is; }
  109.  
  110.  
  111. #define ITEM_NO_STRM_OPS(ITEM)        \
  112.     ITEM_NO_STRM_INSERT(ITEM)    \
  113.     ITEM_NO_STRM_EXTRACT(ITEM)
  114.  
  115. #define ITEM_NO_REL_STRM_OPS(ITEM)    \
  116.     ITEM_NO_REL_OPS(ITEM)        \
  117.     ITEM_NO_STRM_INSERT(ITEM)    \
  118.     ITEM_NO_STRM_EXTRACT(ITEM)
  119.  
  120. #define ITEM_DEL_ONLY(ITEM)        \
  121.     ITEM_NO_REL_OPS(ITEM)        \
  122.     ITEM_NO_ASSIGN(ITEM)        \
  123.     ITEM_NO_COPYINIT(ITEM)        \
  124.     ITEM_NO_STRM_INSERT(ITEM)    \
  125.     ITEM_NO_STRM_EXTRACT(ITEM)
  126.  
  127. #define ITEM_STRMABLE(ITEM,ITEM_STRM_BASE)    \
  128.     ITEM_TEST_ASSIGN(ITEM)            \
  129.     ITEM_CLONE(ITEM)            \
  130.     ITEM_STRM_MUT_DELETE(ITEM)        \
  131.     ITEM_LINK(ITEM)                \
  132.     ITEM_UNLINK(ITEM)            \
  133.     ITEM_STRM_INSERT(ITEM,ITEM_STRM_BASE)    \
  134.     ITEM_STRM_EXTRACT(ITEM,ITEM_STRM_BASE)
  135.  
  136.  
  137.  
  138. template <class ITEM>
  139.  
  140. class CL : cl {
  141.  
  142.  
  143. protected:
  144.  
  145.     CL  (defaultConstructor)
  146.             : cl(defaultConstruct) {}
  147.     void     assign(CL<ITEM>& b)
  148.             { cl::assign(b); }
  149.     cl:: destruct;
  150.     virtual voidCmP DcmP(voidCmP cmP)
  151.             { return CL_D_cmP
  152.             (CLcmPcast(cmP,ITEM)); }
  153.     virtual  void * Dassign(void * D,
  154.             const void * S)
  155.             { return CL_D_ASSIGN
  156.             ((ITEM *)D,(ITEM *)S); }
  157.     virtual  void * Dnew(const void * D)
  158.             { return  CL_D_NEW
  159.             ((ITEM *)D); }
  160.     virtual  void   Ddelete(void * D)
  161.             { CL_D_DELETE((ITEM *)D); }
  162.     virtual  int    Dattach(void * D)
  163.             { return CL_D_LINK((ITEM *)D,
  164.             (void *) this); }
  165.     virtual  void   Ddetach(void * D)
  166.             { CL_D_UNLINK((ITEM *)D,
  167.             (void *) this); }
  168.     virtual     int    Dput(ostream& os, void * D)
  169.             { return ((os << (ITEM **) &D)?
  170.             1 : 0); }
  171.     virtual     void * Dget(istream& is)
  172.             { ITEM * D; is >> &D;
  173.             return (void *) D; }
  174.     virtual  int    put(ostream& os)
  175.             { return cl::put(os); }
  176.     virtual  int    get(istream& is)
  177.             { return cl::get(is); }
  178.     friend   ostream& operator<<(ostream& os,
  179.             CL<ITEM>& b);
  180.     friend   istream& operator>>(istream& is,
  181.             CL<ITEM>& b);
  182.     cl:: vforEach;
  183.  
  184.  
  185. public:
  186.  
  187. /*  Constructors and destructor  */
  188.  
  189.     CL (unsigned flags = CL_BIND_ONLY,
  190.         unsigned maxNodes = CL_MAXNODES,
  191.         unsigned limit = CL_LIMIT,
  192.         unsigned delta = CL_DELTA) :
  193.         cl(flags,maxNodes,limit,delta)
  194.         {}
  195.     CL (ITEM * argv[],
  196.         unsigned argc = 0U,
  197.         unsigned flags = CL_BIND_ONLY)
  198.         : cl((void **)argv,argc,flags)
  199.         {}
  200.     CL (CL<ITEM>& b)
  201.         : cl(defaultConstruct)
  202.         { assign(b); }
  203.     CL<ITEM>& operator=(CL<ITEM>& b)
  204.         { assign(b); return *this; }
  205.     CL (const char * filename)
  206.         : cl(defaultConstruct)
  207.         { (void) cl::load(filename); }
  208.     int     load(const char * filename)
  209.         { return cl::load(filename); }
  210.     int     save(const char * filename)
  211.         { return cl::save(filename); }
  212.     ITEM ** vector(ITEM ** argv = (ITEM **)0,
  213.         unsigned argc = 0U)
  214.         { return (ITEM **)cl::
  215.         vector((void **)argv,argc); }
  216.     virtual ~CL() { destruct(); }
  217.  
  218.  
  219. /*  Housekeeping Primitives  */
  220.  
  221.     cl:: Limit;
  222.     cl:: setLimit;
  223.     cl:: pack;
  224.     cl:: Delta;
  225.     cl:: setDelta;
  226.     cl:: Nodes;
  227.     cl:: MaxNodes;
  228.     cl:: setMaxNodes;
  229.     cl:: vacancy;
  230.     cl:: vacancyNonElastic;
  231.     cl:: Flags;
  232.     cl:: setFlags;
  233.     cl:: resetFlags;
  234.     CL<ITEM>&  operator<<(CL<ITEM>&
  235.             (*manipulator)(CL<ITEM>&))
  236.             { return (manipulator?
  237.             (*manipulator)
  238.             (*this)    : *this); }
  239.  
  240.  
  241. /*  Elastic Array Primitives  */
  242.  
  243.     ITEM *   atIns(unsigned n, ITEM * D)
  244.             { return (ITEM *)cl::
  245.             atIns(n,(void *)D); }
  246.     ITEM *   atInsNew(unsigned n, const ITEM * D)
  247.             { return (ITEM *)cl::
  248.             atInsNew(n,(const void *)D); }
  249.     ITEM *   atRmv(unsigned n)
  250.             { return (ITEM *)cl::
  251.             atRmv(n); }
  252.     cl:: allRmv;
  253.     cl:: atDel;
  254.     ITEM *   atDelAsg(unsigned n, ITEM * D)
  255.             { return (ITEM *)cl::
  256.             atDelAsg(n,(void *)D); }
  257.     cl:: allDel;
  258.     cl:: allClr;
  259.     ITEM *   atPut(unsigned n, ITEM * D)
  260.             { return (ITEM *)cl::
  261.             atPut(n,(void *)D); }
  262.     ITEM *   atPutNew(unsigned n, const ITEM * D)
  263.             { return (ITEM *)cl::
  264.             atPutNew(n,(const void *)D); }
  265.     ITEM *   atPutAsg(unsigned n, const ITEM * D)
  266.             { return (ITEM *)cl::
  267.             atPutAsg(n,(const void *)D); }
  268.     ITEM *   atGet(unsigned n)
  269.             { return (ITEM *)cl::
  270.             atGet(n); }
  271.     ITEM *   operator[](unsigned n)
  272.             { return atGet(n); }
  273.     ITEM *   atGetAsg(unsigned n, ITEM * D)
  274.             { return (ITEM *)cl::
  275.             atGetAsg(n,(void *) D); }
  276.     ITEM *   atXchg(unsigned n, ITEM * D)
  277.             { return (ITEM *)cl::
  278.             atXchg(n,(void *) D); }
  279.     unsigned index(const ITEM * D)
  280.             { return cl::
  281.             index((const void *)D); }
  282.     void     forEach(CLapplY(B,ITEM), ...)
  283.             { va_list args;
  284.             va_start(args,B);
  285.             vforEach((voidApplY)B,args);
  286.             va_end(args); }
  287.  
  288.  
  289.  
  290. /*  Stack - Deque - Queue Primitives  */
  291.  
  292.     ITEM *   push(ITEM * D)
  293.             { return (ITEM *)cl::
  294.             push((void *) D); }
  295.     ITEM *   pushNew(const ITEM * D)
  296.             { return (ITEM *)cl::
  297.             pushNew((const void *)D); }
  298.     ITEM *   pop()
  299.             { return (ITEM *)cl::
  300.             pop(); }
  301.     CL<ITEM>&  operator>>(ITEM *& D)
  302.             { D = atRmv(0U);
  303.             return *this; }
  304.     cl:: popDel;
  305.     ITEM *   popDelAsg(ITEM * D)
  306.             { return (ITEM *)cl::
  307.             popDelAsg((void *)D); }
  308.     ITEM *   top()
  309.             { return (ITEM *)cl::
  310.                 top(); }
  311.     ITEM *   topAsg(ITEM * D)
  312.             { return (ITEM *)cl::
  313.             topAsg((void *)D); }
  314.     ITEM *   insQ(ITEM * D)
  315.             { return (ITEM *)cl::
  316.             insQ((void *)D); }
  317.     CL<ITEM>&  operator<<(ITEM * D)
  318.             { atIns(Nodes(),D);
  319.                    return *this; }
  320.     ITEM *   insQNew(const ITEM * D)
  321.             { return (ITEM *)cl::
  322.             insQNew((const void *)D); }
  323.     ITEM *   unQ()
  324.             { return (ITEM *)cl::
  325.             unQ(); }
  326.     cl:: unQDel;
  327.     ITEM *   unQDelAsg(ITEM * D)
  328.             { return (ITEM *)cl::
  329.             unQDelAsg((void *)D); }
  330.     ITEM *   rear()
  331.             { return (ITEM *)cl::
  332.                 rear(); }
  333.     ITEM *   rearAsg(ITEM * D)
  334.             { return (ITEM *)cl::
  335.             rearAsg((void *)D); }
  336.  
  337.  
  338. /*  List (single and double linked) Primitives  */
  339.  
  340.     cl:: CurNode;
  341.     cl:: setCurNode;
  342.     ITEM *   ins(ITEM * D)
  343.             { return (ITEM *)cl::
  344.             ins((void *)D); }
  345.     ITEM *   insNew(const ITEM * D)
  346.             { return (ITEM *)cl::
  347.             insNew((const void *)D); }
  348.     ITEM *   rmv()
  349.             { return (ITEM *)cl::
  350.             rmv(); }
  351.     cl:: del;
  352.     ITEM *   delAsg(ITEM * D)
  353.             { return (ITEM *)cl::
  354.             delAsg((void *)D); }
  355.     ITEM *   put(ITEM * D)
  356.             { return (ITEM *)cl::
  357.             put((void *)D); }
  358.     ITEM *   putNew(const ITEM * D)
  359.             { return (ITEM *)cl::
  360.             putNew((const void *)D); }
  361.     ITEM *   putAsg(const ITEM * D)
  362.             { return (ITEM *)cl::
  363.             putAsg((const void *)D); }
  364.     ITEM *   get()
  365.             { return (ITEM *)cl::
  366.             get(); }
  367.     operator ITEM *()  { return get(); }
  368.     ITEM *   getAsg(ITEM * D)
  369.             { return (ITEM *)cl::
  370.             getAsg((void *)D); }
  371.     ITEM *   next()
  372.             { return (ITEM *)cl::
  373.             next(); }
  374.     ITEM *   operator++()
  375.             { return next(); }
  376.     ITEM *   nextAsg(ITEM * D)
  377.             { return (ITEM *)cl::
  378.             nextAsg((void *)D); }
  379.     ITEM *   prev()
  380.             { return (ITEM *)cl::
  381.             prev(); }
  382.     ITEM *   operator--()
  383.             { return prev(); }
  384.     ITEM *   prevAsg(ITEM * D)
  385.             { return (ITEM *)cl::
  386.             prevAsg((void *)D); }
  387.  
  388.  
  389. /* Priority Q, Set, Bag, Dictionary, Sort Primitives */
  390.  
  391.     cl:: Sorted;
  392.     cl:: unSort;
  393.     void     setCmP(CLcmP(cmP,ITEM)
  394.             = CLcmP0(ITEM))
  395.             { cl::setCmP
  396.             ((voidCmP)cmP); }
  397.     CLcmP(CmPfnc,ITEM) { return CLcmPcast
  398.             (cl::CmP(),ITEM); }
  399.     int      sort(CLcmP(cmP,ITEM)
  400.             = CLcmP0(ITEM))
  401.             { return cl::sort
  402.             ((voidCmP)cmP); }
  403.     ITEM *   insSort(ITEM * D)
  404.             { return (ITEM *)cl::
  405.             insSort((void *)D); }
  406.     ITEM *   insSortNew(const ITEM * D)
  407.             { return (ITEM *)cl::
  408.             insSortNew((const void *)D); }
  409.     ITEM *   insUnique(ITEM * D)
  410.             { return (ITEM *)cl::
  411.             insUnique((void *)D); }
  412.     ITEM *   insUniqueNew(const ITEM * D)
  413.             { return (ITEM *)cl::
  414.             insUniqueNew((const void *)D);}
  415.     ITEM *   findFirst(const ITEM * K)
  416.             { return (ITEM *)cl::
  417.             findFirst((const void *)K); }
  418.     ITEM *   findNext(const ITEM * K)
  419.             { return (ITEM *)cl::
  420.             findNext((const void *)K); }
  421.     ITEM *   findLast (const ITEM * K)
  422.             { return (ITEM *)cl::
  423.             findLast((const void *)K); }
  424.     ITEM *   findPrev(const ITEM * K)
  425.             { return (ITEM *)cl::
  426.             findPrev((const void *)K); }
  427.     unsigned findAll(const ITEM * K)
  428.             { return cl::
  429.             findAll((const void *)K); }
  430.  
  431.  
  432. };    /*  class CL  */
  433.  
  434.  
  435. template <class ITEM>
  436. inline ostream& operator<<(ostream& os,
  437.         CL<ITEM>& b)
  438.     { (void) b.put(os); return os; }
  439.  
  440. template <class ITEM>
  441. inline istream& operator>>(istream& is,
  442.         CL<ITEM>& b)
  443.     { (void) b.get(is); return is; }
  444.  
  445.  
  446. #endif  /*  cl_hpt  */
  447.